home *** CD-ROM | disk | FTP | other *** search
/ Carousel / CAROUSEL.cdr / mactosh / code / p_serlib.sit / Serial Library Source Code / serial.read.dll.c < prev    next >
C/C++ Source or Header  |  1989-07-27  |  6KB  |  211 lines
  1. /***********************************************************************/
  2. /*    
  3. /*    serial.read.dll.c
  4. /*    by Atul Butte
  5. /*    Copyright ⌐ 1989 by Microsoft Corporation
  6. /*    All Rights Reserved
  7. /*
  8. /*    version 1.0
  9. /*    
  10. /*    
  11. /*    This CALL/REGISTER will read from the serial port the number of chars
  12. /*    specified.
  13. /*    
  14. /*    Excel usage:
  15. /*    
  16. /*    = Register( "serial library", "serial.read", "GHHJCG" )
  17. /*    = Call( ref, portNumber, numberChars, maxTime, readConfigStr, )
  18. /*    
  19. /*    where
  20. /*        portNumber        = number of port (1 = modem, 2 = printer)
  21. /*        numberChars        = number of characters to read
  22. /*        maxTime            = maximum amount of time to wait for characters
  23. /*                          in 1/60 second units
  24. /*        readConfigStr    = configuration of communications protocol, etc
  25. /*
  26. /*    The extra comma at the end of the CALL parameter list must be present.
  27. /*    
  28. /***********************************************************************/
  29.  
  30. /***********************************************************************/
  31. /*
  32. /*    D E F I N E S
  33. /*
  34. /***********************************************************************/
  35.  
  36. #define ROUTINE_NAME    "serial.read"
  37. #define hNIL 0L
  38. #define pNIL 0L
  39.  
  40. /***********************************************************************/
  41. /*
  42. /*    I N C L U D E S
  43. /*
  44. /***********************************************************************/
  45.  
  46. #include "serial.h"
  47. #include "error.h"
  48. #include "get_port.h"
  49. #include "get_read_flags.h"
  50.  
  51. /***********************************************************************/
  52. /*
  53. /*    P R O T O T Y P E S
  54. /*
  55. /***********************************************************************/
  56.  
  57. /***********************************************************************/
  58. /*
  59. /*    main
  60. /*
  61. /***********************************************************************/
  62.  
  63. pascal char *main( port, cchDesired, timeDur, pszConfig, pstBuff )
  64.  
  65.     unsigned short            port;                    /* serial port to use */
  66.     unsigned short            cchDesired;                /* number of characters desired */
  67.     unsigned long            timeDur;                /* maximum time to wait for chars (in ticks) */
  68.     char                    *pszConfig;                /* communications configuration string */
  69.     char                    *pstBuff;                /* buffer in which to return string */
  70.     
  71. {
  72.     register OSErr            err;                    /* result code from Toolbox routines */
  73.     ParamBlockRec            param;                    /* parameter block for read/write */
  74.     
  75.     Boolean                    fEcho = false;            /* flag for echoing characters */
  76.     Boolean                    fEdit = false;            /* flag for allowing edit characters */
  77.     Boolean                    fStripLF = false;        /* flag for stripping line feeds */
  78.     Boolean                    fStrip8Bit = false;        /* flag for stripping high bit */
  79.     Boolean                    fAddLF = false;            /* flag for adding LF after CR */
  80.     Boolean                    fIgnore = false;        /* flag for ignoring escape chars */
  81.     
  82.     register short            cch = 0;                /* number of characters received */
  83.     long                    cchBuff = 0;            /* number of characters waiting in read buffer */
  84.     register unsigned long    timeStop;                /* time at which to stop */
  85.     register char            *pst;                    /* pointer to current character in buffer */
  86.     short                    refIn;                    /* reference number for input port */
  87.     short                    refOut;                    /* reference number for output port */
  88.     register char            ch;                        /* character read */
  89.     char                    echoBackspace[3];        /* characters to send to echo Backspace */
  90.     char                    echoLinefeed;            /* characters to send to echo Linefeed */
  91.     
  92.     RememberA0();
  93.     SetUpA4();
  94.     
  95.     if( cchDesired > 254 ) {
  96.         display_error( "Number of characters to read cannot be greater than 254." );
  97.         RestoreA4( );
  98.         return( pstBuff );
  99.     }
  100.     if( pszConfig == pNIL ) {
  101.         display_error( "The fourth parameter must be a configuration string." );
  102.         RestoreA4( );
  103.         return( pstBuff );
  104.     }
  105.     if( pstBuff == pNIL ) {
  106.         display_error( "The fifth parameter must be a pointer to an empty string buffer." );
  107.         RestoreA4( );
  108.         return( pstBuff );
  109.     }
  110.     pst = pstBuff;
  111.     *pst = 0;
  112.     pst++;
  113.     
  114.     err = get_port( port, &refIn, &refOut );
  115.     if( err != noErr ) {
  116.         display_error( "Illegal port number." );
  117.         RestoreA4( );
  118.         return( pstBuff );
  119.     }
  120.     
  121.     get_read_flags( pszConfig, &fEcho, &fEdit, &fStripLF, &fStrip8Bit, &fAddLF, &fIgnore );
  122.     
  123.     if( fEcho ) {
  124.         echoBackspace[0] = kchBackspace;
  125.         echoBackspace[1] = ' ';
  126.         echoBackspace[2] = kchBackspace;
  127.  
  128.         if( fAddLF ) {
  129.             echoLinefeed = kchLinefeed;
  130.         }
  131.     }
  132.     
  133.     timeStop = TickCount( ) + timeDur;
  134.  
  135.     while( cch < cchDesired ) {
  136.         if( ( timeDur != 0 ) && ( TickCount( ) >= timeStop ) ) {
  137.             break;
  138.         }
  139.         err = SerGetBuf( refIn, &cchBuff );
  140.         if( err != noErr ) {
  141.             display_error( "Error trying to count buffer." );
  142.             break;
  143.         }
  144.         if( cchBuff == 0 )
  145.             continue;
  146.         param.ioParam.ioReqCount = 1;
  147.         param.ioParam.ioBuffer = pst;
  148.         param.ioParam.ioRefNum = refIn;
  149.         err = PBRead( ¶m, false );
  150.         if( err != noErr ) {
  151.             display_error( "Error reading from serial port." );
  152.             break;
  153.         }
  154.         if( fStrip8Bit ) {
  155.             *pst &= 0x7f;
  156.         }
  157.         ch = *pst;
  158.         if( ( (ch == kchBackspace) || (ch == kchDelete) ) && (fEdit) ) {
  159.             cch -= 2;
  160.             if( cch >= -1 ) {
  161.                 pst -= 2;
  162.             } else {
  163.                 cch = -1;
  164.                 pst -= 1;
  165.             }
  166.             if( fEcho ) {
  167.                 param.ioParam.ioReqCount = 3;
  168.                 param.ioParam.ioRefNum = refOut;
  169.                 param.ioParam.ioBuffer = echoBackspace;
  170.                 err = PBWrite( ¶m, false );
  171.                 if( err != noErr ) {
  172.                     display_error( "Error echoing backspace to serial port." );
  173.                     break;
  174.                 }
  175.             }
  176.         } else if( fEcho ) {        /* if not a backspace or delete */
  177.             param.ioParam.ioReqCount = 1;
  178.             param.ioParam.ioRefNum = refOut;
  179.             err = PBWrite( ¶m, false );
  180.             if( err != noErr ) {
  181.                 display_error( "Error echoing to serial port." );
  182.                 break;
  183.             }
  184.             if( (ch == kchReturn) && (fAddLF) ) {
  185.                 param.ioParam.ioReqCount = 1;
  186.                 param.ioParam.ioRefNum = refOut;
  187.                 param.ioParam.ioBuffer = &echoLinefeed;
  188.                 err = PBWrite( ¶m, false );
  189.                 if( err != noErr ) {
  190.                     display_error( "Error echoing linefeed to serial port." );
  191.                     break;
  192.                 }
  193.             }
  194.         }
  195.         if( (ch == kchLinefeed) && (fStripLF) ) {
  196.             pst--;
  197.             cch--;
  198.         }
  199.         pst++;
  200.         cch++;
  201.     }
  202.     *pstBuff = cch;
  203.     
  204.     RestoreA4( );
  205.     return( pstBuff );
  206. }
  207.  
  208. #include "get_read_flags.c"
  209. #include "get_port.c"
  210.  
  211.